package com.ns.school.common.base;

import com.github.pagehelper.PageHelper;
import com.ns.school.common.constant.StaticVarY;
import com.ns.school.common.utils.CollUtil;
import com.ns.school.common.utils.DateUtil;
import com.ns.school.common.utils.AESUtil;
import com.ns.school.common.utils.StrUtil;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 最终基类
 */
public class BaseClass {

    // 通用常量
    public static final int NO = 0;
    public static final int YES = 1;

    /**
     * 判断字符 不是空的 （空格也算空字符）
     *
     * @param str 字符串
     * @return boolean
     */
    protected static boolean notBlank(Object str) {
        return !isBlank(str);
    }

    /**
     * 判断字符 不是空的 （空格也算空字符）
     *
     * @param str 字符串
     * @return boolean
     */
    protected static boolean notBlank(String str) {
        return !isBlank(str);
    }

    /**
     * 判断字符串是否为空（空格也算字符）
     */
    public static boolean isBlank(final CharSequence cs) {
        if (cs == null) {
            return true;
        }
        final int strLen = cs.length();
        if (strLen == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(cs.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断字符串是否为空（空格也算字符）
     *
     * @param str 字符串
     * @return boolean
     */
    protected static boolean isBlank(final Object str) {
        if (str == null) {
            return true;
        } else if (str instanceof String) {
            return isBlank((String) str);
        }
        return false;
    }

    /**
     * 判断字符 不是空的
     *
     * @param str 字符串
     * @return boolean
     */
    protected static boolean notEmpty(String str) {
        return !isEmpty(str);
    }

    protected static boolean notEmpty(Number str) {
        return !isEmpty(str);
    }

    /**
     * <p>Checks if a CharSequence is empty ("") or null.</p>
     */
    public static boolean isEmpty(final CharSequence cs) {
        return cs == null || cs.length() == 0;
    }

    /**
     * 判断字符串是否为空
     *
     * @param obj
     * @return
     */
    public static boolean isEmpty(final Object obj) {
        if (obj == null) {
            return true;
        } else if (obj instanceof String) {
            return isEmpty((String) obj);
        }
        return false;
    }

    public static boolean isEmpty(final Number cs) {
        return cs == null;
    }

    /**
     * 判断是否有内容
     * <p>
     * <pre class="code">
     * hasText(null) = false
     * hasText("") = false
     * hasText(" ") = false
     * hasText("12345") = true
     * hasText(" 12345 ") = true
     * </pre>
     *
     * @param str
     * @return
     */
    protected static boolean hasText(String str) {
        return notBlank(str);
    }

    /**
     * 判断是否没有内容
     *
     * @param str
     * @return
     */
    protected static boolean hasNoText(String str) {
        return !hasText(str);
    }

    /**
     * 判断字符 是纯数字
     *
     * @param str 字符串
     * @return boolean
     */
    protected static boolean isNumeric(String str) {
        if (isBlank(str)) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断字符 不是纯数字
     *
     * @param str 字符串
     * @return boolean
     */
    protected static boolean notNumeric(String str) {
        return !isNumeric(str);
    }

    /**
     * 将对象转换为字符串（空对象转换为""）
     *
     * @param str
     * @return
     */
    protected static String toString(Object str) {
        return toString(str, "");
    }

    /**
     * 将对象转换为字符串
     *
     * @param str
     * @param def 空对象转换为该默认值
     * @return
     */
    protected static String toString(Object str, String def) {
        if (isBlank(str)) {
            return def;
        } else {
            return String.valueOf(str);
        }
    }

    /**
     * 将字符转换成int数字
     *
     * @param str
     * @return
     */
    protected static Integer toInteger(String str) {
        return toInteger(str, null);
    }

    /**
     * 将字符转换成int数字
     *
     * @param str
     * @param def 空对象转换为该默认值
     * @return
     */
    protected static Integer toInteger(String str, Integer def) {
        if (isBlank(str)) {
            return def;
        } else {
            return Integer.valueOf(str);
        }
    }

    /**
     * 将字符转换成long数字
     *
     * @param str
     * @return
     */
    protected static Long toLong(String str) {
        return toLong(str, null);
    }

    /**
     * 将字符转换成long数字
     *
     * @param str
     * @param def 空对象转换为该默认值
     * @return
     */
    protected static Long toLong(String str, Long def) {
        if (isBlank(str)) {
            return def;
        } else {
            return Long.valueOf(str);
        }
    }

    /**
     * 将字符转换成double数字
     *
     * @param str
     * @return
     */
    protected static Double toDouble(String str) {
        if (isBlank(str)) {
            return null;
        } else {
            return Double.valueOf(str);
        }
    }

    private static final Pattern compile = Pattern.compile("^((\\d{1,8})|(\\d{1,8}\\.\\d{1,2}))$");

    /**
     * 判断是否为金额(小数位可选,最多为2位)
     *
     * @param s
     * @return
     */
    protected static boolean isMoney(String s) {
        if (StrUtil.isEmpty(s)) {
            return false;
        }
        Matcher isNum = compile.matcher(s);
        return isNum.matches();
    }

    /**
     * 判断是否为非金额(小数位可选,最多为2位)
     *
     * @param s
     * @return
     */
    protected static boolean notMoney(String s) {
        return !isMoney(s);
    }

    /**
     * 格式化金额
     *
     * @param s
     * @return
     */
    protected static String parseMoney(String s) {
        DecimalFormat df = new DecimalFormat("#0.00");
        return df.format(Double.valueOf(s));
    }

    /**
     * 解密id
     */
    protected static Integer decode(String encryptionId) {
        String idStr = AESUtil.decryption(StaticVarY.AES_SK, encryptionId);
        if (notEmpty(idStr)) {
            return Integer.parseInt(idStr);
        }
        return null;
    }

    /**
     * 解密id
     */
    protected static Long decodeLong(String encryptionId) {
        String idStr = AESUtil.decryption(StaticVarY.AES_SK, encryptionId);
        if (notEmpty(idStr)) {
            return Long.parseLong(idStr);
        }
        return null;
    }

    /**
     * 解密id
     */
    public static List<Integer> decodeIntList(String encryptionStr) {
        List<String> str = CollUtil.parseStr2List(encryptionStr);
        return decodeIntList(str);
    }

    /**
     * 解密id
     */
    public static List<Integer> decodeIntList(List<String> list) {
        if (CollUtil.isEmpty(list)) {
            return new ArrayList<>();
        }
        List<Integer> t = new ArrayList<>();
        for (String s : list) {
            String res = AESUtil.decryption(StaticVarY.AES_SK, s);
            if (notEmpty(res) && StrUtil.isNum(res)) {
                t.add(Integer.valueOf(res));
            }
        }
        return t;
    }

    /**
     * 解密id
     */
    public static List<Long> decodeLongList(String encryptionStr) {
        List<String> str = CollUtil.parseStr2List(encryptionStr);
        return decodeLongList(str);
    }

    /**
     * 解密id
     */
    public static List<Long> decodeLongList(List<String> list) {
        if (CollUtil.isEmpty(list)) {
            return new ArrayList<>();
        }
        List<Long> t = new ArrayList<>();
        for (String s : list) {
            String res = AESUtil.decryption(StaticVarY.AES_SK, s);
            if (notEmpty(res) && StrUtil.isNum(res)) {
                t.add(Long.valueOf(res));
            }
        }
        return t;
    }

    /**
     * 解密id
     */
    protected static String decodeStr(String encryptionId) {
        return AESUtil.decryption(StaticVarY.AES_SK, encryptionId);
    }

    /**
     * 加密id
     */
    protected static String encode(String id) {
        return AESUtil.encryption(StaticVarY.AES_SK, id);
    }

    /**
     * 加密id
     */
    protected static String encode(Integer id) {
        return AESUtil.encryption(StaticVarY.AES_SK, id);
    }

    /**
     * 加密id
     */
    protected static String encode(Long id) {
        return AESUtil.encryption(StaticVarY.AES_SK, id);
    }

    /**
     * 判断给定对象是否null,是则返回默认值,否则返回对象自己
     *
     * @param obj
     * @param def
     * @param <T>
     * @return
     */
    public static <T> T defaultIfNull(T obj, T def) {
        if (obj == null) {
            return def;
        }
        return obj;
    }

    /**
     * 判断给定对象是否空,是则返回默认值,否则返回对象自己
     *
     * @param cs
     * @param def
     * @return
     */
    public static String defaultIfEmpty(final String cs, String def) {
        if (cs == null || cs.isEmpty()) {
            return def;
        }
        return cs;
    }

    /**
     * 判断给定的对象是否大于0
     *
     * @param obj
     * @return
     */
    public static boolean biggerZero(Integer obj) {
        if (obj == null) {
            return false;
        }
        return obj > 0;
    }

    /**
     * 判断给定的对象是否大于0
     *
     * @param obj
     * @return
     */
    public static boolean biggerZero(Long obj) {
        if (obj == null) {
            return false;
        }
        return obj > 0;
    }

    /**
     * 判断给定的对象是否大于0
     *
     * @param obj
     * @return
     */
    public static boolean biggerZero(Double obj) {
        if (obj == null) {
            return false;
        }
        return obj > 0;
    }

    /**
     * 判断是否是本地or测试环境
     *
     * @return
     */
    protected static boolean isDevOrTestProfile() {
        return "dev".equals(StaticVarY.profile) || "test".equals(StaticVarY.profile);
    }

    /**
     * 判断是否是本地环境
     *
     * @return
     */
    protected static boolean isLocalProfile() {
        return "dev".equals(StaticVarY.profile);
    }

    /**
     * 判断是否是测试环境
     *
     * @return
     */
    protected static boolean isTestProfile() {
        return "test".equals(StaticVarY.profile);
    }

    /**
     * 判断是否是正式环境
     *
     * @return
     */
    protected static boolean isProdProfile() {
        return "prod".equals(StaticVarY.profile);
    }

    /**
     * 获取当前环境
     *
     * @return
     */
    protected static String getProfile() {
        return StaticVarY.profile;
    }

    public static List<Long> doTimeIn(Integer timeIn, String createTimeStr) {
        List<Long> res = new ArrayList<>(2);
        long start = -1L;
        long end = -1L;
        if (StrUtil.isEmpty(timeIn)) {
            start = DateUtil.endOfDay(-7);
            end = DateUtil.endOfDay();
            // entity.setTimeIn("3");
        } else {
            switch (timeIn) {
                case 1: // 当天
                    start = DateUtil.beginOfDay();
                    end = DateUtil.endOfDay();
                    break;
                case 2: // 昨天
                    start = DateUtil.beginOfDay(-1);
                    end = DateUtil.endOfDay(-1);
                    break;
                case 3: // 最近7天
                    start = DateUtil.endOfDay(-7);
                    end = DateUtil.endOfDay();
                    break;
                case 4: // 当月
                    start = DateUtil.beginOfMonth();
                    end = DateUtil.endOfMonth();
                    break;
                case 6: // 上月
                    start = DateUtil.beginOfMonthLast();
                    end = DateUtil.endOfMonthLast();
                    break;
                case 5: // 其他
                    String bdate = null;
                    String edate = null;
                    if (StrUtil.notEmpty(createTimeStr)) {
                        String createTime = DateUtil.dateReplace2Int(createTimeStr);
                        if (createTime.length() == 16) {
                            bdate = createTime.substring(0, 8);
                            edate = createTime.substring(8, 16);
                        } else if (createTime.length() == 8) {
                            bdate = createTime.substring(0, 8);
                            edate = bdate;
                        }
                    }
                    if (StrUtil.notEmpty(bdate) && StrUtil.notEmpty(edate)) {
                        start = Long.parseLong(DateUtil.dateReplace2Int(bdate) + "000000");
                        end = Long.parseLong(DateUtil.dateReplace2Int(edate) + "235959");
                    }
                    break;
                default:
                    break;
            }
        }
        if (start > 0) {
            res.add(start);
        }
        if (end > 0) {
            res.add(end);
        }
        return res;
    }

    protected void startPage(BaseVO entity) {
        PageHelper.startPage(entity.getPage(), entity.getLimit());
    }

    protected void startPage(int page, int size) {
        PageHelper.startPage(page, size);
    }

}